In traditional computer system network architectures, devices such as computer servers and storage devices are interconnected through wires (e.g., copper or optical) which transport data between the devices. FIG. 1A shows an example of a wire 101 over which formatted data is transported, for example, using the Ethernet protocol. The data is typically in the form of “bits” which are represented as “1's” and “0's” and are physically formed by voltage, current and/or light. Devices can be connected, for example, locally on the same motherboard, or between different pieces of equipment through longer connectors such as copper wires or optical fiber using connectors such as Small Form-factor Pluggable (SFP), Quad Small Form-factor Pluggable (QSFP), or Gigabit Interface Converter (GBIC) modules. FIG. 1B shows an exemplary QSFP connected cable 111.
The data on an interconnect or wire is generally encoded into a standard protocol (such as, for example, Ethernet, Peripheral Component Interconnect (PCI), Peripheral Component Interconnect Express (PCIe or PCI-E), Serial Attached SCSI (SAS), Serial AT Attachment (Serial ATA or SATA), FiberChannel, or Infiniband) to accomplish reliable data transfer and interoperability between or among different devices and manufacturers. Two devices using the same protocol can be considered akin to two persons speaking the same language, and, when different protocols or languages are used, one or more translators may be required.
In certain configurations, there may exist several devices and/or computer applications that require multiple protocols. For example, consider a “server” architecture, in which the server (e.g., a box containing at least one motherboard with microprocessor and running computer programs) is connected to, and intended to provide functionality or services (e.g., performing computations or sharing data or resources) for, other “client” devices or programs.
The server needs to communicate, through the network, with one or more other devices or applications, which can include a hard disk drive (HDD) or solid-state drive (SSD), a general-purpose graphics processing unit (GP-GPU, GPGPU or GPGP), and/or other devices, applications or servers. To enable such communications, interfaces are used to create physical connections, such as from an on-board processor within the server to a peripheral device. These interfaces run protocols, such as PCIe, DDR (double data rate) and/or others. Each of the devices or other servers can have its own interface protocol. For example, the HDD may employ (connect through) SATA or SAS, and the SSD may employ SAS or PCIe, while the GP-GPU may employ PCIe. The network connecting these devices together may be Ethernet, which is generally considered a reliable and pervasive networking protocol, or another suitable protocol.
One approach to dealing with a configuration such as described above is to use translators to allow communications involving multiple protocols. For example, a Network Interface Card (NIC) may be used to connect together a server with an HDD or SSD. In that case, the NIC may be inserted between the server and the network connection to translate, for example, from the PCIe to Fiberchannel protocol. On the other end of the network, the HDD or SSD is connected through another NIC, which would translate from Fiberchannel to PCIe, or to a Host Bus Adapter which translates Fiberchannel to SAS or SATA. This translation process can be both inefficient and costly. For example, the NICs introduce latency and overhead in the data transactions which reduces overall system performance and increases power and cost.
Another approach is to create multiple separate, standalone networks, with each network using a particular protocol. For example, a configuration may include an Ethernet network and a FiberChannel network, each separate and optimized for the type of data being transmitted. However, this approach also has downsides, for example, the need to setup and maintain multiple networks.
Another approach, sometimes referred to as “tunneling,” is to embed one protocol inside another, for example, putting PCIe data “frames” into Ethernet frames to be transported over Ethernet and then returned to PCIe on the other end of the connection. This approach generally reduces the performance of the connection to the lowest common denominator, or the slowest protocol. In this PCIe/Ethernet example, enhanced PCIe performance is lost as the data is transmitted as Ethernet packets during transmission, which results, for example, in certain latency burdens inherent in the Ethernet protocol.
In addition, the industry has generally standardized or shown a preference for several connector or module types and extensive infrastructure is already in place utilizing these types of connectors. For example, QSFP (such as shown in FIG. 1B and discussed above) is a pervasive module/connector that is used for Ethernet connectivity and carries four “lanes” of data, typically Ethernet. There is an inherent bias in the industry to continue using such connectors already in place, if possible, even as connectivity architectures evolve.
There exists a need for improved multi-protocol connectivity systems, apparatus and methods to overcome obstacles and deficiencies associated with conventional computer networks and environments involving multiple devices and associated protocols.